/**
 * projectName: Junit5Demo0410
 * fileName: Junit5Demo_1_1_Assert.java
 * packageName: com.junit5.xunit.junit.demo
 * date: 2021-04-10 上午10:28
 */
package xunit.junit.demo;

import com.sun.org.glassfish.gmbal.Description;
import org.junit.internal.runners.statements.RunAfters;
import org.junit.jupiter.api.DisplayName;
import util.Calculator;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;

import java.util.ArrayList;
import java.util.Collection;

import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;

/**
 * @version: V1.0
 * @author: kuohai
 * @className: Junit5Demo_1_1_Assert
 * @packageName: com.junit5.xunit.junit.demo
 * @description: 断言示例
 * @data: 2021-04-10 上午10:28
 **/
@DisplayName("用lambda表达式实现软断言")
@Description("写了两种写法，一种是在代码尾部用lambda表达式一次性将所有断言添加到软断言List中，代码上会稍微复杂一点；另一种是在每一个打算断言的地方将断言用lambda表达式添加到软断言List中")
public class Junit5Demo_1_2_AssertAll {
    @Test
    @DisplayName("加法测试")
    @Description("软断言，写法1：末尾一次性添加")
    public void addTest() throws InterruptedException {
        int result = Calculator.add(4, 2);
        System.out.println("加法计算结果： " + result);

        int result01 = Calculator.add(1, -1);
        System.out.println("加法计算结果： " + result01);

        int result02 = Calculator.add(0, 2);
        System.out.println("加法计算结果： " + result02);

        assertAll("加法计算结果校验1！",
                () -> {
                    assertEquals(6, result);
                    System.out.println("Done01!");
                },
                () -> assertEquals(1, result01),
                () -> assertEquals(1, result02)
        );
    }


    @Test
    @DisplayName("加法测试2")
    @Description("软断言，写法2：每次添加")
    public void addTest02() throws InterruptedException {
        ArrayList<Executable> assertList = new ArrayList<>();

        int result = Calculator.add(4, 2);
        System.out.println("加法计算结果： " + result);
        assertList.add(() -> assertEquals(6, result));

        int result01 = Calculator.add(1, -1);
        System.out.println("加法计算结果： " + result01);
        assertList.add(() -> assertEquals(6, result01));

        int result02 = Calculator.add(0, 2);
        System.out.println("加法计算结果： " + result02);
        assertList.add(() -> assertEquals(6, result02));

        System.out.println("debugger!");

        assertAll("加法计算结果校验2", assertList.stream());
    }

    @Test
    @DisplayName("减法测试")
    @Description("减法测试，一次性添加断言")
    void subtractTest() throws InterruptedException {

        int result1 = Calculator.subtract(10, 2);
        System.out.println("减法计算结果1：" + result1);

        int result2 = Calculator.subtract(100, 20);
        System.out.println("减法计算结果1：" + result2);

        int result3 = Calculator.subtract(999, 89);
        System.out.println("减法计算结果1：" + result3);

        /**
         * 使用软断言的方式来保证所有代码执行完成
         * 写法1：代码末尾一次性添加断言，代码复杂度会稍微高一点，且断言与对应代码相隔较远，易出错
         */
        assertAll("减法测试，一次性添加断言！",
                () -> assertEquals(8, result1),
                () -> assertEquals(80, result2),
                () -> assertEquals(900, result3)
        );
    }

    @Test
    @DisplayName("减法测试2")
    @Description("陈亮晶追加，减法测试，软断言方式2：在每个要断言的地方使用lambda表达式添加到assertAll流中")
    void subtractTest2() throws InterruptedException {

        ArrayList<Executable> assertList = new ArrayList<Executable>();

        int result1 = Calculator.subtract(10, 2);
        System.out.println("减法计算结果1：" + result1);
        assertList.add(() -> assertEquals(8, result1));

        int result2 = Calculator.subtract(100, 20);
        System.out.println("减法计算结果1：" + result2);
        assertList.add(() -> assertEquals(80, result2));

        /**
         * 使用软断言的方式来保证所有代码执行完成
         * 写法2：每个原本该断言的地方用lambda表达式的方式将其添加到软断言列表中，末尾转换为流后用assertAll执行全部断言
         */
        int result3 = Calculator.subtract(999, 89);
        System.out.println("减法计算结果1：" + result3);
        assertList.add(() -> assertEquals(900, result3));

        assertAll("减法测试软断言写法2：", assertList.stream());
    }
}